/*
 * Copyright (c) 2007-2009 Strasbourg University
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 * Author: Sebastien Vincent <vincent@clarinet.u-strasbg.fr>
 */

#ifndef NDISC_CACHE_H
#define NDISC_CACHE_H

#include "ns3/ipv6-address.h"
#include "ns3/net-device.h"
#include "ns3/nstime.h"
#include "ns3/output-stream-wrapper.h"
#include "ns3/packet.h"
#include "ns3/ptr.h"
#include "ns3/timer.h"

#include <list>
#include <map>
#include <stdint.h>

namespace ns3
{

class NetDevice;
class Ipv6Interface;
class Ipv6Header;
class Icmpv6L4Protocol;

/**
 * @ingroup ipv6
 *
 * @brief IPv6 Neighbor Discovery cache.
 */
class NdiscCache : public Object
{
  public:
    class Entry;

    /**
     * @brief Get the type ID
     * @return type ID
     */
    static TypeId GetTypeId();

    /**
     * @brief Default value for unres qlen.
     */
    static const uint32_t DEFAULT_UNRES_QLEN = 3;

    /**
     * @brief Constructor.
     */
    NdiscCache();

    /**
     * @brief Destructor.
     */
    ~NdiscCache() override;

    // Delete default and copy constructor, and assignment operator to avoid misuse
    NdiscCache(const NdiscCache&) = delete;
    NdiscCache& operator=(const NdiscCache&) = delete;

    /**
     * @brief Get the NetDevice associated with this cache.
     * @return NetDevice
     */
    Ptr<NetDevice> GetDevice() const;

    /**
     * @brief Get the Ipv6Interface associated with this cache.
     * @returns The Ipv6Interface.
     */
    Ptr<Ipv6Interface> GetInterface() const;

    /**
     * @brief Lookup in the cache.
     * @param dst destination address.
     * @return the entry if found, 0 otherwise.
     */
    virtual NdiscCache::Entry* Lookup(Ipv6Address dst);

    /**
     * @brief Lookup in the cache for a MAC address.
     * @param dst destination MAC address.
     * @return a list of matching entries.
     */
    std::list<NdiscCache::Entry*> LookupInverse(Address dst);

    /**
     * @brief Add an entry.
     * @param to address to add
     * @return an new Entry
     */
    virtual NdiscCache::Entry* Add(Ipv6Address to);

    /**
     * @brief Delete an entry.
     * @param entry pointer to delete from the list.
     */
    void Remove(NdiscCache::Entry* entry);

    /**
     * @brief Flush the cache.
     */
    void Flush();

    /**
     * @brief Set the max number of waiting packet.
     * @param unresQlen value to set
     */
    void SetUnresQlen(uint32_t unresQlen);

    /**
     * @brief Get the max number of waiting packet.
     * @return max number
     */
    uint32_t GetUnresQlen();

    /**
     * @brief Set the device and interface.
     * @param device the device
     * @param interface the IPv6 interface
     * @param icmpv6 the ICMPv6 protocol
     */
    void SetDevice(Ptr<NetDevice> device,
                   Ptr<Ipv6Interface> interface,
                   Ptr<Icmpv6L4Protocol> icmpv6);

    /**
     * @brief Print the NDISC cache entries
     *
     * @param stream the ostream the NDISC cache entries is printed to
     */
    void PrintNdiscCache(Ptr<OutputStreamWrapper> stream);

    /**
     * @brief Clear the NDISC cache of all Auto-Generated entries
     */
    void RemoveAutoGeneratedEntries();

    /**
     * @brief Pair of a packet and an Ipv4 header.
     */
    typedef std::pair<Ptr<Packet>, Ipv6Header> Ipv6PayloadHeaderPair;

    /**
     * @ingroup ipv6
     *
     * @brief A record that holds information about a NdiscCache entry.
     */
    class Entry
    {
      public:
        /**
         * @brief Constructor.
         * @param nd The NdiscCache this entry belongs to.
         */
        Entry(NdiscCache* nd);

        virtual ~Entry() = default;

        /**
         * @brief The Entry state enumeration.
         */
        enum NdiscCacheEntryState_e
        {
            INCOMPLETE,          /**< No mapping between IPv6 and L2 addresses */
            REACHABLE,           /**< Mapping exists between IPv6 and L2 addresses */
            STALE,               /**< Mapping is stale */
            DELAY,               /**< Try to wait contact from remote host */
            PROBE,               /**< Try to contact IPv6 address to know again its L2 address */
            PERMANENT,           /**< Permanent Mapping exists between IPv6 and L2 addresses */
            STATIC_AUTOGENERATED /**< Permanent entries generate by NeighborCacheHelper*/
        };

        /**
         * @brief The state of the entry.
         */
        NdiscCacheEntryState_e m_state;

        /**
         * @brief Changes the state to this entry to INCOMPLETE.
         * @param p packet that wait to be sent
         */
        void MarkIncomplete(Ipv6PayloadHeaderPair p);

        /**
         * @brief Changes the state to this entry to REACHABLE.
         * @param mac MAC address
         * @return the list of packet waiting
         */
        std::list<Ipv6PayloadHeaderPair> MarkReachable(Address mac);

        /**
         * @brief Changes the state to this entry to PROBE.
         */
        void MarkProbe();

        /**
         * @brief Changes the state to this entry to STALE.
         * @param mac L2 address
         * @return the list of packet waiting
         */
        std::list<Ipv6PayloadHeaderPair> MarkStale(Address mac);

        /**
         * @brief Changes the state to this entry to STALE.
         */
        void MarkStale();

        /**
         * @brief Changes the state to this entry to REACHABLE.
         */
        void MarkReachable();

        /**
         * @brief Change the state to this entry to DELAY.
         */
        void MarkDelay();

        /**
         * @brief Change the state to this entry to PERMANENT.
         */
        void MarkPermanent();

        /**
         * @brief Changes the state of this entry to auto-generated.
         *
         * The entry must have a valid MacAddress.
         */
        void MarkAutoGenerated();

        /**
         * @brief Add a packet (or replace old value) in the queue.
         * @param p packet to add
         */
        void AddWaitingPacket(Ipv6PayloadHeaderPair p);

        /**
         * @brief Clear the waiting packet list.
         */
        void ClearWaitingPacket();

        /**
         * @brief Is the entry STALE
         * @return true if the entry is in STALE state, false otherwise
         */
        bool IsStale() const;

        /**
         * @brief Is the entry REACHABLE
         * @return true if the entry is in REACHABLE state, false otherwise
         */
        bool IsReachable() const;

        /**
         * @brief Is the entry DELAY
         * @return true if the entry is in DELAY state, false otherwise
         */
        bool IsDelay() const;

        /**
         * @brief Is the entry INCOMPLETE
         * @return true if the entry is in INCOMPLETE state, false otherwise
         */
        bool IsIncomplete() const;

        /**
         * @brief Is the entry PROBE
         * @return true if the entry is in PROBE state, false otherwise
         */
        bool IsProbe() const;

        /**
         * @brief Is the entry PERMANENT
         * @return true if the entry is in PERMANENT state, false otherwise
         */
        bool IsPermanent() const;

        /**
         * @brief Is the entry STATIC_AUTOGENERATED
         * @return True if the state of this entry is auto-generated; false otherwise.
         */
        bool IsAutoGenerated() const;

        /**
         * @brief Get the MAC address of this entry.
         * @return the L2 address
         */
        Address GetMacAddress() const;

        /**
         * @brief Set the MAC address of this entry.
         * @param mac the MAC address to set
         */
        void SetMacAddress(Address mac);

        /**
         * @brief If the entry is a host or a router.
         * @return true if the node is a router, 0 if it is a host
         */
        bool IsRouter() const;

        /**
         * @brief Set the node type.
         * @param router true is a router, false means a host
         */
        void SetRouter(bool router);

        /**
         * @brief Get the time of last reachability confirmation.
         * @return time
         */
        Time GetLastReachabilityConfirmation() const;

        /**
         * @brief Start the reachable timer.
         */
        void StartReachableTimer();

        /**
         * @brief Update the reachable timer.
         */
        void UpdateReachableTimer();

        /**
         * @brief Start retransmit timer.
         */
        void StartRetransmitTimer();

        /**
         * @brief Start probe timer.
         */
        void StartProbeTimer();

        /**
         * @brief Start delay timer.
         */
        void StartDelayTimer();

        /**
         * @brief Stop NUD timer and reset the NUD retransmission counter
         */
        void StopNudTimer();

        /**
         * @brief Function called when reachable timer timeout.
         */
        void FunctionReachableTimeout();

        /**
         * @brief Function called when retransmit timer timeout.
         * It verify that the NS retransmit has reached the max so discard the entry
         * otherwise it retransmit a NS.
         */
        void FunctionRetransmitTimeout();

        /**
         * @brief Function called when probe timer timeout.
         */
        void FunctionProbeTimeout();

        /**
         * @brief Function called when delay timer timeout.
         */
        void FunctionDelayTimeout();

        /**
         * @brief Set the IPv6 address.
         * @param ipv6Address IPv6 address
         */
        void SetIpv6Address(Ipv6Address ipv6Address);

        /**
         * @brief Get the IPv6 address.
         * @returns The IPv6 address
         */
        Ipv6Address GetIpv6Address() const;

        /**
         * @brief Get the state of the entry.
         * @returns The state of the entry
         */
        NdiscCacheEntryState_e GetEntryState() const;

        /**
         * @brief Print this entry to the given output stream.
         *
         * @param os the output stream to which this Ipv6Address is printed
         */
        void Print(std::ostream& os) const;

      protected:
        /**
         * @brief the NdiscCache associated.
         */
        NdiscCache* m_ndCache;

      private:
        /**
         * @brief The IPv6 address.
         */
        Ipv6Address m_ipv6Address;

        /**
         * @brief The MAC address.
         */
        Address m_macAddress;

        /**
         * @brief The list of packet waiting.
         */
        std::list<Ipv6PayloadHeaderPair> m_waiting;

        /**
         * @brief Type of node (router or host).
         */
        bool m_router;

        /**
         * @brief Timer (used for NUD).
         */
        Timer m_nudTimer;

        /**
         * @brief Last time we see a reachability confirmation.
         */
        Time m_lastReachabilityConfirmation;

        /**
         * @brief Number of NS retransmission.
         */
        uint8_t m_nsRetransmit;
    };

  protected:
    /**
     * @brief Dispose this object.
     */
    void DoDispose() override;

    /**
     * @brief Neighbor Discovery Cache container
     */
    typedef std::map<Ipv6Address, NdiscCache::Entry*> Cache;
    /**
     * @brief Neighbor Discovery Cache container iterator
     */
    typedef std::map<Ipv6Address, NdiscCache::Entry*>::iterator CacheI;

    /**
     * @brief A list of Entry.
     */
    Cache m_ndCache;

  private:
    /**
     * @brief The NetDevice.
     */
    Ptr<NetDevice> m_device;

    /**
     * @brief the interface.
     */
    Ptr<Ipv6Interface> m_interface;

    /**
     * @brief the icmpv6 L4 protocol for this cache.
     */
    Ptr<Icmpv6L4Protocol> m_icmpv6;

    /**
     * @brief Max number of packet stored in m_waiting.
     */
    uint32_t m_unresQlen;
};

/**
 * @brief Stream insertion operator.
 *
 * @param os the reference to the output stream
 * @param entry the NdiscCache::Entry
 * @returns the reference to the output stream
 */
std::ostream& operator<<(std::ostream& os, const NdiscCache::Entry& entry);

} /* namespace ns3 */

#endif /* NDISC_CACHE_H */
